import java.util.ArrayList;
import java.util.List;

class Message<T> {
    private T message ;
    public T getMessage() {
        return message;
    }
    public void setMessage(T message) {
        this.message = message;
    }
}
public class test {
    public static void main(String[] args) {
        Message<String> message = new Message<>() ;
        message.setMessage("比特就业课欢迎您");
        fun(message);

        Message<Integer> message1 = new Message<>();
        message1.setMessage(10);
        fun(message1);
    }
    // 并不知道Message<?> 传的是什么类型,所以使用通配符,可以匹配传入的类型
    public static void fun(Message<?> temp){
        System.out.println(temp.getMessage());
        // temp.setMessage(12);
        // 不可以设置通配符,因为不知道它的类型是什么
    }
}
/*
public class test {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        List<String> list1 = new ArrayList<>();
    }
}
*/
/*
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        Stack<Character> stack = new Stack<>();

        int len = s.length();
        for(int i = 0;i < len;i++){
            char ch = s.charAt(i);
            if(stack.isEmpty()){
            stack.add(ch);
            }else{
                if(ch == stack.peek()){
                    stack.pop();
                }else{
                    stack.add(ch);
                }
            }
        }
        if(stack.isEmpty()){
            System.out.println(0);
            return;
        }
        StringBuffer t = new StringBuffer();
        while(!stack.isEmpty()){
            char ch = stack.pop();
            t.append(ch);
        }
        t.reverse();
        for(int i = 0;i < t.length();i++){
            System.out.print(t.charAt(i));
        }
    }
}
 */
/*
class Solution
{
public:
    string minWindow(string s, string t)
    {
        int hash1[128];// 用来存t中字符出现的次数
        int hash2[128];// 用来统计s中字符出现的次数
        int n = s.size(),kinds = 0;
        int minlen = INT_MAX,begin = -1;
        for(const auto& ch : t)
        {
            if(hash1[ch] == 0) kinds++;// 统计有多少种字符种类
            hash1[ch]++;
        }
        // count 表示种类
        for(int left = 0,right = 0,count = 0;right < n;++right)
        {
          // 进窗口 + 维护count
          char a = s[right];
          hash2[a]++;
          if(hash2[a] == hash1[a]) count++;
          // 判断
          while(count == kinds)// 种类数相同
          {
            // 更新结果
            if(right - left + 1 < minlen)
            {
                minlen = right - left + 1;
                begin = left;
            }
            // 出窗口 + 维护count
            char b = s[left];
            if(hash2[b] == hash1[b]) count--;
            hash2[b]--;
            left++;
          }
        }
        return begin == -1 ? "" : s.substr(begin,minlen);
    }
};
 */

/*
class Solution
{
public:
    int subarraySum(vector<int>& nums, int k)
    {
        unordered_map<int,int> hash;
        hash[0] = 1;// 整个数组加起来为k

        int sum = 0,ret = 0;
        for(auto ch : nums)
        {
            sum += ch;// 记录当前的前缀和
            if(hash.count(sum-k)) ret += hash[sum-k];
            hash[sum]++;
        }
        return ret;
    }
};
 */